Importing modules from parent folder

Question

I am running Python 2.5.

This is my folder tree:

ptdraft/
  nib.py
  simulations/
    life/
      life.py

(I also have __init__.py in each folder, omitted here for readability)

How do I import the nib module from inside the life module? I am hoping it is possible to do without tinkering with sys.path.

Note: The main module being run is in the ptdraft folder.

Canvas

What's your PYTHONPATH setting? – Margaretemargaretha

Ross: I looked there. What should I do about it? I already have a __init__.py. S.Lott: I don't know how to check... – Canvas

echo $PYTHONPATH from the shell; import sys; print sys.path from within Python. docs.python.org/tutorial/… – Margaretemargaretha

@FlipMcF Google is a bubbled search engine, so the fact that this result is pretty high up for you doesn't matter. Far more important is the fact that the non-bubbled search engine, DuckDuckGo, also ranks this very highly. – Novitiate

@FlipMcF There's nothing wrong with doing an absolute import like in hasen's answer. This is done hundreds of times in Django. It's absolutely acceptable. In some cases doing a relative import is nicer and shorter, so feel free to use these methods interchangeably. – Canvas

@RamRachum My opinion has since changed to Absolute Imports. Relative imports are nice, but "Explicit is better than Implicit" and to a lesser extent "Namespaces are a 'honkin great idea" – Psych

@Psych but I heard relative imports is considered as bad behavior? – Selfhelp

You may want to take a look at this definitive guide chrisyeh96.github.io/2017/08/08/… – Bristling

I strongly recommend skipping past all sys.path or PYTHONPATH answers and checking out np8's excellent answer. Yes, it's a long read. Yes, it looks like a lot of work. But it's the only answer that actually solves the problem correctly and cleanly. – Kizzee

Whatever happened to executable pseudocode? Why is it such a pain to import modules from a parent folder in Python? This is absurd. – Northwestward

@eric: It’s hard only if you’re being inconsistent: using a file layout appropriate to a package (a complicated, reusable library, of which your script is but a client) but trying to run it as a throwaway script (without even python -m). – Breannabreanne

Why is this such a pain? After reading through all the discussion and answers, there's still no reasonable simple solution. – Nga

I'd argue that tjk's answer is the simplest and most pythonic. If you're making a python function that imports other files, you aren't writing one-off scripts, so your 'script files' are actually just module files, and while you can run them as script files, it's presented as more of an additional feature in the documentation than the 'correct' way to run them. – Anabas

@ApollyssupportsMonica There is no pain. If you want to directly import code from outside of the package, you simply update the sys.path. Nothing difficult or hackish about it. Note that the standard way is to not directly import any outside code at all - rather to install that code as a dependency using the pip tool. – Avocado

For pytest I've solved it on the pyproject.toml (details: https://mcmap.net/q/14035/-importing-modules-from-parent-folder) – Binny

Answer 1

It seems that the problem is not related to the module being in a parent directory or anything like that.

You need to add the directory that contains ptdraft to PYTHONPATH

You said that import nib worked with you, that probably means that you added ptdraft itself (not its parent) to PYTHONPATH.

Internuncio

Having to add everything to pythonpath is not a good solution if you are working with a lot of packages that are never going to be reused. – Mismate

@JasonCheng: Then why are they packages? – Breannabreanne

For me this answer has worked out. However, to make it more explicit, the procedure is to import sys and then sys.path.append("..\<parent_folder>") – Kimmy

@JasonCheng you don't have to export the modified PYTHONPATH or your shell profile, you can also choose to set it only for a single call to python (so it is only modified on a per-execution basis) or you can put it in some kind of .env file (per-folder basis). – Schnabel

Answer 2

You could use relative imports (Python >= 2.5):

from ... import nib

(What’s New in Python 2.5) PEP 328: Absolute and Relative Imports

Cess

ValueError: Attempted relative import in non-package – Asdic

@endolith: You have to be in a package, i.e., you must have an init.py file. – Sulfonation

Attempted relative import beyond toplevel package – Leblanc

@btk There's nothing wrong with doing an absolute import like in hasen's answer. This is done hundreds of times in Django. It's absolutely acceptable. In some cases doing a relative import is nicer and shorter, so feel free to use these methods interchangeably. – Canvas

See also the following answer, since adding __init__.py is not the only thing you have to do: stackoverflow.com/questions/11536764/… – Intermediate

To be even more precise, you need an __init__.py file. – Water

@karadeniz Well, that's not more precise. In fact, you omitted the fact that you need a __init__.py in the parent directory. – Landy

To summarise this answer to a related question: for relative or absolute imports to work (without nasty path hacks, or going to the trouble of installing as an editable package) you simply need to run using python -m, e.g. in this case python -m ptdraft.nib. All the imports then get correctly resolved, see PEP338. – Motet

Why can't we just stay with import nib? This works for me. – Oleomargarine

how can we go up and then down? – Horntail

ImportError: attempted relative import with no known parent package – Istria

@Leblanc that is a separate issue; please see stackoverflow.com/questions/30669474/… . – Desquamate

@Istria please see stackoverflow.com/questions/14132789/… similarly. – Desquamate

@VictorFerreira use the appropriate number of .s to go up, then use the folder names to go down. For example, another source file adjacent to life.py could import life.py like from . import life, or like from ..life import life, or like from ...simulations.life import life. It could not go further than this, unless a folder higher up were established as the package root. – Desquamate

Answer 3

I posted a similar answer also to the question regarding imports from sibling packages. You can see it here.

Solution without sys.path hacks

Summary

• Wrap the code into one folder (e.g. packaged_stuff)
• Create a pyproject.toml (older alternative: setup.py)
• Pip install the package in editable state with pip install -e <myproject_folder>
• Import using from packaged_stuff.modulename import function_name

Setup

I assume the same folder structure as in the question

.
└── ptdraft
    ├── __init__.py
    ├── nib.py
    └── simulations
        ├── __init__.py
        └── life
            ├── __init__.py
            └── life.py

I call the . the root folder, and in my case it is located in C:\tmp\test_imports.

Steps

---

1) Add a pyproject.toml to the root folder

The contents of the pyproject.toml can be simply

[project]
name = "ptdraft"
version = "0.1.0"
description = "My small project"

[build-system]
build-backend = "flit_core.buildapi"
requires = ["flit_core >=3.2,<4"]

Basically "any" valid pyproject.toml would work. This is just a minimal working example, which uses flit as build backend.

---

2) Use a virtual environment

If you are familiar with virtual environments, activate one, and skip to the next step. Usage of virtual environments are not absolutely required, but they will really help you out in the long run (when you have more than 1 project ongoing..). The most basic steps are (run in the root folder)

• Create virtual env
  • python -m venv venv
• Activate virtual env
  • . venv/bin/activate (Linux) or ./venv/Scripts/activate (Win)
• Deactivate virtual env
  • deactivate (Linux)

To learn more about this, just Google out "python virtualenv tutorial" or similar. You probably never need any other commands than creating, activating and deactivating.

Once you have made and activated a virtual environment, your console should give the name of the virtual environment in parenthesis

PS C:\tmp\test_imports> python -m venv venv
PS C:\tmp\test_imports> .\venv\Scripts\activate
(venv) PS C:\tmp\test_imports>

---

3) pip install your project in editable state

Install your top level package (here ptdraft) using pip. The trick is to use the -e flag when doing the install. This way it is installed in an editable state, and all the edits made to the .py files will be automatically included in the installed package. Note that the -e flag with pyproject.toml requires pip 21.3 or newer.

In the root directory, run

pip install -e . (note the dot, it stands for "current directory")

You can also see that it is installed by using pip freeze

(venv) PS C:\tmp\test_imports> pip install -e .
Obtaining file:///home/user/projects/ptdraft
  Installing build dependencies ... done
  Checking if build backend supports build_editable ... done
  Getting requirements to build editable ... done
  Preparing editable metadata (pyproject.toml) ... done
....
Successfully built ptdraft
Installing collected packages: ptdraft
Successfully installed ptdraft-0.1.0
(venv) PS C:\tmp\test_imports> pip freeze
ptdraft==0.1.0

---

4) Import by prepending mainfolder to every import

In this example, the mainfolder would be ptdraft. This has the advantage that you will not run into name collisions with other module names (from python standard library or 3rd party modules).

---

Example Usage

nib.py

def function_from_nib():
    print('I am the return value from function_from_nib!')

life.py

from ptdraft.nib import function_from_nib

if __name__ == '__main__':
    function_from_nib()

Running life.py

(venv) PS C:\tmp\test_imports> python .\ptdraft\simulations\life\life.py
I am the return value from function_from_nib!

Stall

Why does this work? Is it changing the PYTHONPATH behind the scenes somehow? – Gastro

Your PYTHONPATH variable remains the same. You simply install your python code with pip (in an editable state). – Stall

And what does the installation process do? Isn't it including the root folder in the pythonpath? How is it helping python find the module nib.py when referred in life.py? – Gastro

Also, why is this better or more elegant than using the sys.path approach? – Gastro

I think PYTHONPATH is still untouched, since it always includes the installed modules. You can see the added package by using "pip freeze", but I don't know the exact magic behind installing packages in editable state. I cannot answer your questions in greater accuracy than this off the top of my head, sorry. – Stall

The elegancy is a matter of taste, I guess ;) I can not think of a situation where I would use the sys.path -append-method instead, but maybe there are proper use cases for that, too. – Stall

@HomeroBarrocasSEsmeraldo Good questions. PYTHONPATH env var is untouched. This installs into site-packages, which is already on sys.path and where the code would typically be installed by end users. That's better than sys.path hacks (and you can include using PYTHONPATH in that category of path hacks) because it means the code in development should behave the same way for you as it does for other users. In contrast, when using path modifications, import statements would be resolved in a different way. – Magnetoelectricity

how do I include it in the requirements.txt? – Larkins

This is by far, THE best solution I've read. This creates a link to your current directory so all updates to the code is directly reflected into your working directory. In the event you need to delete this entry, Manually delete the egg file and remove the entry from easy-install in dist-packages (site-packages if you used pip). – Wiring

Removing the package is also possible with pip uninstall package-name, and package name can be read from pip list. – Stall

This answer really helped med a lot getting my data analysis app up and running. Thanks for the detailed description and the clear steps. – Derange

How do I bookmark this excellent answer? I frequently have this problem and forget the best practice, and probably on occasion miss this answer since it's not the selected one. Thanks for posting it! – Dardan

@DanNguyen I have found the "share" (text) link below the answers being helpful. It is the direct link to the answer, and it makes bookmarking and sharing answers easier. – Stall

why making the python import headache even more complicated? We have to write a setup file, a virtual env, a pip install? omg! – Yung

This solution gave me a minor problem: https://mcmap.net/q/14226/-pip-fatal-error-in-launcher-unable-to-create-process-using-39-quot-39 – Capitular

it's much better than the workaround sys.path.insert(0,'..'). If you use sys solution in a script, there will be a problem later if you want to import a module from that other file. I had this issue in Jupyter and this solution worked the bets. – Elastin

Is this amount of work to import a module still necessary in 2020 on python 3.8? I cannot believe how complicated this is. – Debenture

For smaller projects, sure the path hack works, while for larger ones this answer has helped me a great deal! Can you imaging tracking where you've edited sys.path within your code when you have 7 directories and 50+ files, and pushing it to git and having your teammates reusing your code becomes a disaster! Thank you np8! I believe this is the best solution that is most convenient in long term – Supreme

PEP 517 does not support editable installs as noted on setuptools . What is the safest, most flexible way of adding directories to python lookup path? I'd like to avoid sys.path and pythonpath hacks, and so far this is the best answer. – Strophanthus

How would this work if your top level directory name contained dashes? The import with that name will not work seemingly – Yeomanry

@EmilTerman You can add it to requirements.txt by adding -e . on it's own line. I put this at the top of my requirements.txt. – Bryannabryansk

Thanks! It's a frustrating how hard it is to import modules from nested packages and sibling directories – Chromo

If you're using conda as a package manager, you will need to run conda develop . rather than pip install -e . – Anabas

I followed this approach to check if PyCharm sees the import (similar hierarchical order) : I did not manage to import upper-level modules/scripts : I can see the root directory for the import, but I cannot import "root_directory.package_name.script_X" it did not work in my case. Does this solution work only when inside venv? – Timm

Timbus: This works with and without virtual environments. You could make a separate SO question from your case if you wish. – Stall

This answer is comprehensive, but it misrepresents a simple task as complex. Virtual environments are something you should have set up anyway (to avoid interfering with a system Python), and installing projects is a fundamental skill. The answer really boils down to: "install the package for your project, and then the package root will be on the path so you can use import normally". Once this is set up, both relative (as long as you don't go past the package root) and absolute (starting from the package root) imports work. – Desquamate

@KarlKnechtel This is not a simple task being representative as complex. This is complex and frankly awful in 2022. Python should generate a list of available module names from the __init__.py files in a small local project and make them available for importing but it doesn't. Making your entire project a package sounds overkill if you just want to reference functions from a few different files in different directories. – Danieledaniell

@IanSmith Making the project a package is an implicit part of the process of making it possible for other people to use your code. __init__.py files are not required and actually do very little when empty. If the project has a folder structure that makes any of this non-trivial, it is inherently not a "small local project". It would be a very bad idea to make a flat list of "available" module names; that directly contravenes "Explicit is better than implicit" and "Namespaces are a honking great idea - let's do more of those!". The task is not complex and I already explained why. – Desquamate

@KarlKnechtel Lol, if we want to quote aphorisms "If the implementation is hard to explain, it's a bad idea." Let's make namespaces easier by default :). Right now they are a pain. I have yet to see a 1 minute method on making them. If they were easy more people would talk about them and use them. Why am I forced to use a virtual environment? Is that necessary in Java, Typescript, Dart? Not really.. – Danieledaniell

It's not hard to explain at all. You use a dotted path, just like attributes on objects - because they are; modules and packages are represented as objects, and modules and sub-packages are attached as attributes to their containing packages. And again - The answer really boils down to: "install the package for your project, and then the package root will be on the path so you can use import normally". That's a one-sentence explanation, and we have to understand pip and venv and packaging anyway. – Desquamate

In my pip freeze I see a line for `-e git+github.com...' instead of my local directory. How do I fix this? – Arthromere

While the idea of this is elegant, huge correction here: installing with pip in editable mode is substantially different than installing in the regular mode. It will create a symbolic link, not install in the site-packages folder! For this reason, while I went with this answer, I am installing it the regular way, not in editable mode. – Yasmeen

@NikoFöhr Useful answer but I have a common collaborative use case where I am having potential issue with this. Suppose two people are collaborating on a python project via. Github, developing locally on their own machines while using a shared network installation of the conda environment. Now installing the current repo as an editable package inside this conda env will only work for one person at a time. If using a local env installation, your solution will still work. Not sure if the workflow itself is flawed but we prefer shared network conda env over local envs to be space efficient. – Eeg

I haven't yet made myself familiar with "shared network installation" of a conda environment, so I can't comment other than perhaps using editable installs in such an environment deserves a question of its own :) – Stall

Answer 4

Relative imports (as in from .. import mymodule) only work in a package. To import 'mymodule' that is in the parent directory of your current module:

import os
import sys
import inspect

currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parentdir = os.path.dirname(currentdir)
sys.path.insert(0, parentdir) 

import mymodule

Note: The __file__ attribute is not always given. Instead of using os.path.abspath(__file__) I suggest using the inspect module to retrieve the filename (and path) of the current file.

Gross

something a little shorter: sys.path.insert(1, os.path.join(sys.path[0], '..')) – Alford

Any reason to avoid sys.path.append() instead of the insert? – Foment

@Foment - It can matter if somewhere else then the parentdir, but in one of the paths allready specified in sys.path, there is another module with the name 'mymodule'. Inserting the parentdir as the first element of the sys.path list assures that the module from parentdir will be imported instead. – Gross

@JHolta If you're not dealing with packages, yours is the best solution. – Dupaix

@JHolta great idea. sys.path.insert(1, os.path.realpath(os.path.pardir)) works too. – Theocrasy

@Theocrasy Actually, using sys.path[0] is necessary if your working directory is different from it. See stackoverflow.com/questions/714063/…. – Gilliette

ImportError: attempted relative import with no known parent package – Trivalent

Answer 5

You can use an OS-dependent path in "module search path" which is listed in sys.path.

So you can easily add the parent directory like the following:

import sys
sys.path.insert(0, '..')

If you want to add the parent-parent directory,

sys.path.insert(0, '../..')

This works both in Python 2 and Python 3.

Worthen

This is relative to the current directory, not even necessarily the one containing the main script. – Breannabreanne

This method is worked in PyCharm, but not in VS Code. – Dexterous

worked great for me! thanks! ... but i needed sibling dir, so my solution was sys.path.insert(0,'../sibling_dir') – Canine

@DavisHerring To fix it, use an absolute path. – Avocado

@Jeyekomon: That merely replaces one of the several forms of fragility in this approach with another. – Breannabreanne

@DavisHerring is right. What you probably want instead is sys.path.append(os.path.dirname(os.path.abspath(__file__))) – Faus

Answer 6

I don't know much about Python 2.
In Python 3, the parent folder can be added as follows:

import sys
sys.path.append('..')

...and then one is able to import modules from it.

Maidenly

This only works if your current working directory is such that '..' leads to the directory with the module in question. – Tarnation

@Tarnation is right. You probably want sys.path.append(os.path.dirname(os.path.abspath(__file__))) instead. This will work no matter what the working directory is. – Faus

This doesn't work with VS Code @Faus 's suggestion works with VS code. – Telescopic

Answer 7

If adding your module folder to the PYTHONPATH didn't work, You can modify the sys.path list in your program where the Python interpreter searches for the modules to import, the Python documentation says:

When a module named spam is imported, the interpreter first searches for a built-in module with that name. If not found, it then searches for a file named spam.py in a list of directories given by the variable sys.path. sys.path is initialized from these locations:

• the directory containing the input script (or the current directory).
• PYTHONPATH (a list of directory names, with the same syntax as the shell variable PATH).
• the installation-dependent default.

After initialization, Python programs can modify sys.path. The directory containing the script being run is placed at the beginning of the search path, ahead of the standard library path. This means that scripts in that directory will be loaded instead of modules of the same name in the library directory. This is an error unless the replacement is intended.

Knowing this, you can do the following in your program:

import sys
# Add the ptdraft folder path to the sys.path list
sys.path.append('/path/to/ptdraft/')

# Now you can import your module
from ptdraft import nib
# Or just
import ptdraft

Maurita

Your answer is good, but may not always work and is not very portable. If the program was moved to a new location, /path/to/ptdraft would have to be edited. There are solutions that work out the current directory of the file and import it from the parent folder that way as well. – Collar

@Collar what are those techniques? – Communicate

@Communicate for example, the answer stackoverflow.com/questions/714063/…. – Collar

Answer 8

Here is an answer that's simple so you can see how it works, small and cross-platform. It only uses built-in modules (os, sys and inspect), so it should work on any operating system (OS) because Python is designed for that.

Shorter code for answer - fewer lines and variables

from inspect import getsourcefile
import os.path as path, sys
current_dir = path.dirname(path.abspath(getsourcefile(lambda:0)))
sys.path.insert(0, current_dir[:current_dir.rfind(path.sep)])
import my_module  # Replace "my_module" here with the module name.
sys.path.pop(0)

For fewer lines than this, replace the second line with import os.path as path, sys, inspect. Add inspect. at the start of getsourcefile (line 3) and remove the first line.

• however this imports all of the module so it could need more time, memory and resources.

The code for my answer (longer version)

from inspect import getsourcefile
import os.path
import sys

current_path = os.path.abspath(getsourcefile(lambda:0))
current_dir = os.path.dirname(current_path)
parent_dir = current_dir[:current_dir.rfind(os.path.sep)]

sys.path.insert(0, parent_dir)

import my_module  # Replace "my_module" here with the module name.

It uses an example from a Stack Overflow answer How do I get the path of the current executed file in Python? to find the source (filename) of running code with a built-in tool.

from inspect import getsourcefile
from os.path import abspath

Next, wherever you want to find the source file from you just use:

abspath(getsourcefile(lambda:0))

My code adds a file path to sys.path, the Python path list because this allows Python to import modules from that folder.

After importing a module in the code, it's a good idea to run sys.path.pop(0) on a new line when that added folder has a module with the same name as another module that is imported later in the program. You need to remove the list item added before the import, not other paths.

If your program doesn't import other modules, it's safe to not delete the file path because after a program ends (or restarting the Python shell), any edits made to sys.path disappear.

Notes about a filename variable

My answer doesn't use the __file__ variable to get the file path/filename of running code because users here have often described it as unreliable. You shouldn't use it for importing modules from parent folder in programs used by other people.

Some examples where it doesn't work (quote from this Stack Overflow question):

• it can't be found on some platforms. It sometimes isn't the full file path

• py2exe doesn't have a __file__ attribute, but there is a workaround
• When you run from IDLE with execute() there is no __file__ attribute
• OS X 10.6 where I get NameError: global name '__file__' is not defined

Collar

I did this and removed the new path entry with sys.path.pop(0) immediately after importing the desired module. However, subsequent imports still went to that location. For example, I have app/config, app/tools and app/submodule/config. From submodule, I insert app/ to import tools, then remove app/ and try to import config, but I get app/config instead of app/submodule/config. – Tarnation

I figured out that one of tools's imports was also importing config from the parent dir. So when I later tried to do sys.path.pop(0); import config inside submodule, expecting to get app/submodule/config, I was actually getting app/config. Evidently Python returns a cached version of a module with the same name instead of actually checking the sys.path for a module matching that name. sys.path in this case was being altered correctly, Python was just not checking it due to the same-named module already having been loaded. – Tarnation

I think this is the exact reference to the issue I had: docs.python.org/3/reference/import.html#the-module-cache – Tarnation

Some useful information from 5.3.1. The module cache on the documentation page: During import, the module name is looked up in sys.modules ... sys.modules is writable. Deleting a key will invalidate the cache entry for the named module, causing Python to search anew upon its next import. ... Beware though, as if you keep a reference to the module object, invalidate its cache then re-import, the two objects will be different. By contrast, importlib.reload() will reuse and reinitialise the module contents ... – Collar

Even shorter: os.path.realpath(getsourcefile(lambda:0) + "/../.."). Will get current source file appended with two parent directory symbols. I didn't use os.path.sep as getsourcefile was returns a string using / even on Windows. realpath will take care of popping off two directory entries from the full path (in this case, the filename, and then the current directory) which gives the parent directory. – Portend

Answer 9

The pathlib library (included with >= Python 3.4) makes it very concise and intuitive to append the path of the parent directory to the PYTHONPATH:

import sys
from pathlib import Path
sys.path.append(str(Path('.').absolute().parent))

Mceachern

is it possible to use init.py to circumvent this problem? – Selfhelp

Thank you eric, I just removed the confusing part. – Mceachern

import sys from pathlib import Path sys.path.append(str(Path('.').absolute().parent)) – Millisecond

FYI this doesn't work when running visual studio code in debug mode.The ability to import/export globally is on my wishlist for python4 – Stickler

It works for me in VS code debug mode + works for jupyter notebok instead of Path(file) – Cantata

didnt work in visual studio code :( keep getting error No module named 'sharedFunctions' – Willhite

Answer 10

Here is a more generic solution that includes the parent directory into sys.path (it works for me):

import os.path, sys
sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), os.pardir))

Rhearheba

import os, sys\n sys.path.insert(0,os.path.pardir) same thing, but sorther :) (no line feeds in comments) – Morrow

@antiveeranna, if you use os.path.pardir you won't be getting the realpath of the parent, just relative path from where you're calling the sys.path.insert() – Vassili

This answer uses the __file__ variable which can be unreliable (isn't always the full file path, doesn't work on every operating system etc.) as StackOverflow users have often mentioned. Changing the answer to not include it will cause less problems and be more cross-compatible. For more information, see https://mcmap.net/q/14035/-importing-modules-from-parent-folder. – Collar

Answer 11

In a Jupyter Notebook (opened with JupyterLab or Jupyter Notebook)

As long as you're working in a Jupyter Notebook, this short solution might be useful:

%cd ..
import nib

It works even without an __init__.py file.

I tested it with Anaconda 3 on Linux and Windows 7.

Coadjutor

Wouldn't it make sense to add %cd - after the import, so the notebook's current directory stays unchanged. – Lindo

It helps a lot especially when you need to import modules that also import other modules using relative paths. – Chokebore

Answer 12

I found the following way works for importing a package from the script's parent directory. In the example, I would like to import functions in env.py from app.db package.

.
└── my_application
    └── alembic
        └── env.py
    └── app
        ├── __init__.py
        └── db

import os
import sys
currentdir = os.path.dirname(os.path.realpath(__file__))
parentdir = os.path.dirname(currentdir)
sys.path.append(parentdir)

Weis

So, a nice one-liner: sys.path.append(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))) – Shackleford

Modifying sys.path at all is usually a bad idea. You need some way (e.g., PYTHONPATH) for your library to be accessible to other code (or else it’s not really a library); just use that all the time! – Breannabreanne

Answer 13

The previous mentioned solutions are also fine. Another solution to this problem is:

If you want to import anything from top level directory. Then,

from ...module_name import *

Also, if you want to import any module from the parent directory. Then,

from ..module_name import *

Also, if you want to import any module from the parent directory. Then,

from ...module_name.another_module import *

This way you can import any particular method if you want to.

Nodab

This seems to be like it should be, but for some reason this doesn't work in the same way as the sys.path.append hacks above and I cannot import my lib like this. This is what I first tried to do before starting to google :) Ok, it was this ValueError: attempted relative import beyond top-level package – Shackleford

I did some testing and it seems that from ... import name does not mean "import name from top-level", but "import name from the parent's parent". I created a nested directory structure a1/.../a9 of nine directories where each one contains an __init__.py importing the next directory with from . import next_dir. The last directory had a file with from ....... import b which then imported a1/a2/a3/b. (tested with Python 3.8.2) – Cineraria

Used this solution for our library tests. The accepted answer is indeed a proper way of doing things but if I understand correctly that would require exposing the modules which we don't want – Atreus

@Shackleford that is a separate issue. Please see stackoverflow.com/questions/30669474/…. – Desquamate

Answer 14

Two line simplest solution

import os, sys
sys.path.insert(0, os.getcwd()) 

If parent is your working directory and you want to call another child modules from child scripts.

You can import all child modules from parent directory in any scripts and execute it as

python child_module1/child_script.py

Guillemette

This is the only one that worked for me and works best for my use-case: importing the main method from a folder of tests – Pipkin

Answer 15

I think you can try this in that specific example, but in Python 3.6.3:

Ance

ok, you can click this link to download 「import_case」to check the source code case_repo – Ance

However, this method requires that your script is part of a package. This means it might not work if you're running a script directly and the script is not part of an installed package. – Dexterous

Answer 16

For completeness, there one simple solution. It's to run life.py as a module like this:

cd ptdraft
python -m simulations.life.life

This way you can import anything from nib.py as ptdraft directory is in the path.

Lavallee

This is great approach for those who don't want to mess up sys.path or environment variables like PYTHONPATH , for more detail about -m you can check out this stackoverflow thread – Cupro

If you're using vscode, you can do this automatically with the config at stackoverflow.com/questions/57455652/…. – Anabas

Answer 17

For me the shortest and my favorite oneliner for accessing to the parent directory is:

sys.path.append(os.path.dirname(os.getcwd()))

or:

sys.path.insert(1, os.path.dirname(os.getcwd()))

os.getcwd() returns the name of the current working directory, os.path.dirname(directory_name) returns the directory name for the passed one.

Actually, in my opinion Python project architecture should be done the way where no one module from child directory will use any module from the parent directory. If something like this happens it is worth to rethink about the project tree.

Another way is to add parent directory to PYTHONPATH system environment variable.

Bellona

+1 for mentioning the possibility of having to restructure the project (as opposed to throwing a hack at the problem) – Alleviate

this doesn't get the parent, it gets the current – Nicoline

This is a bad idea because it depends on the current directory and not on the location of the file, and therefore it will do different things depending on where you happen be running the script from. – Immense

Answer 18

import sys
sys.path.append('../')

Hyperbaric

this will not work when executed from a different directory. – Papaw

Answer 19

I have a solution specifically for Git repositories.

First I used sys.path.append('..') and similar solutions. This causes especially problems if you are importing files which are themselves importing files with sys.path.append('..').

I then decided to always append the root directory of the Git repository. In one line it would look like this:

sys.path.append(git.Repo('.', search_parent_directories=True).working_tree_dir)

Or in more details like this:

import os
import sys
import git
def get_main_git_root(path):
    main_repo_root_dir = git.Repo(path, search_parent_directories=True).working_tree_dir
    return main_repo_root_dir
main_repo_root_dir = get_main_git_root('.')
sys.path.append(main_repo_root_dir)

For the original question: Based on what the root directory of the repository is, the import would be

import ptdraft.nib

or

import nib

Coadjutor

Btw: this is how to install the git-library: pip install GitPython – Coadjutor

Answer 20

This is the same sort of style as the past answers, but in fewer lines :P

import os, sys
parentdir = os.path.dirname(__file__)
sys.path.insert(0, parentdir)

file returns the location you are working in.

Salamis

For me file is the filename without the path included. I run it using "ipy filename.py". – Japan

Hi @CurtisYallop in the example above we are adding the dir that contains the file [that we are currently in] that the python file is in. The os.path.dirname call with the file name should return the path of the file and we are adding THAT to to the path and not the file explicitly - HTH's :-) – Salamis

You are assuming that __file__ always contains the path plus the file. Sometimes it contains only the filename without the path. – Japan

@CurtisYallop - not at all sir, I am assuming file is the file name and I am using os.path.dirname() to get the path for the file. Have you got an example of this not working? I would love the steps to reproduce – Salamis

You are assuming __file__ == "C:\dir\file.py". Not "file.py". For me, it is "file.py". os.path.dirname(x) returns the path for "x". It examines the string "x", parses it and pulls out the path at the start of the string. For "C:\dir\file.py", it is "C:\dir". For "file.py" is it blank. If there is no path included in the string, it cannot find any path. If you create file "file.py", insert the exact code from the above comment and execute it like this "python file.py" then parentdir is blank. – Japan

@CurtisYallop - No I am not! I am saying that: print /_/file/_/ will give you the filename in your example above "file.py" - I am then saying that you can use os.path.dirname() to pull the full path from that. If you are calling from some weird location and you would like that relational then you can easily find your working dir through the os module -- Jeez! – Salamis

This answer uses the __file__ variable which can be unreliable (isn't always the full file path, doesn't work on every operating system etc.) as StackOverflow users have often mentioned. Changing the answer to not include it will cause less problems and be more cross-compatible. For more information, see https://mcmap.net/q/14035/-importing-modules-from-parent-folder. – Collar

@Collar Do you have an example of when __file__ is reliable? I have been using it and haven't ran into problems with 3.7. The link you posted is around 7 years old, and was using Python 2.XX. I wonder if changes were made in Python3.5++ or so to make file more reliable. Thank you. – Ideally

Answer 21

In a Linux system, you can create a soft link from the "life" folder to the nib.py file. Then, you can simply import it like:

import nib

Ideate

This answer deserves more attentions. symlinks approach is orders of magnitude cleaner than most of the answers on this thread. yet, this is the first time I see someone suggests it. – Backbreaking

I disagree. This is a no-portable solution that also mixes file system layer with python source code. – Windburn

Answer 22

Our folder structure:

/myproject
  project_using_ptdraft/
    main.py
  ptdraft/
    __init__.py
    nib.py
    simulations/
      __init__.py
      life/
        __init__.py
        life.py

The way I understand this is to have a package-centric view. The package root is ptdraft, since it's the top most level that contains __init__.py

All the files within the package can use absolute paths (that are relative to package root) for imports, for example in life.py, we have simply:

import ptdraft.nib

However, to run life.py for package dev/testing purposes, instead of python life.py, we need to use:

cd /myproject
python -m ptdraft.simulations.life.life

Note that we didn't need to fiddle with any path at all at this point.

---

Further confusion is when we complete the ptdraft package, and we want to use it in a driver script, which is necessarily outside of the ptdraft package folder, aka project_using_ptdraft/main.py, we would need to fiddle with paths:

import sys
sys.path.append("/myproject")  # folder that contains ptdraft
import ptdraft
import ptdraft.simulations

and use python main.py to run the script without problem.

Helpful links:

• Python behind the scenes #11: how the Python import system works (see how __init__.py can be used)
• Running package initialization code
• Import a module from both within same package and from outside the package in Python 3
• How to fix "Attempted relative import in non-package" even with __init__.py

Effortful

Answer 23

It's seems to me that you don't really need to import the parent module. Let's imagine that in nib.py you have func1() and data1, you need to use in life.py

nib.py

import simulations.life.life as life
def func1():
   pass
data1 = {}
life.share(func1, data1)

life.py

func1 = data1 = None

def share(*args):
   global func1, data1
   func1, data1 = args

And now you have the access to func1 and data in life.py. Of course you have to be careful to populate them in life.py before you try to use them,

Cupo

Best answer here IMO. – Chryselephantine

Answer 24

Using pathlib.Path

import sys
from pathlib import Path
sys.path.append(str(Path(f"{__file__}").parent.parent))
import my_module

Sneaking

Answer 25

Work with libraries. Make a library called nib, install it using setup.py, let it reside in site-packages and your problems are solved. You don't have to stuff everything you make in a single package. Break it up to pieces.

Diplosis

Your idea is good but some people may want to bundle their module in with their code - perhaps to make it portable and not require putting their modules in site-packages every time they run it on a different computer. – Collar

Answer 26

I had a problem where I had to import a Flask application, that had an import that also needed to import files in separate folders. This is partially using Remi's answer, but suppose we had a repository that looks like this:

.
└── service
    └── misc
        └── categories.csv
    └── test
        └── app_test.py
    app.py
    pipeline.py

Then before importing the app object from the app.py file, we change the directory one level up, so when we import the app (which imports the pipeline.py), we can also read in miscellaneous files like a csv file.

import os,sys,inspect
currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parentdir = os.path.dirname(currentdir)
sys.path.insert(0,parentdir)

os.chdir('../')
from app import app

After having imported the Flask app, you can use os.chdir('./test') so that your working directory is not changed.

Kumquat

Answer 27

After removing some sys path hacks, I thought it might be valuable to add

My preferred solution.

Note: this is a frame challenge - it's not necessary to do in-code.

Assuming a tree,

project
└── pkg
    └── test.py

Where test.py contains

import sys, json; print(json.dumps(sys.path, indent=2)) 

Executing using the path only includes the package directory

python pkg/test.py
[
  "/project/pkg",
 ...
]

But using the module argument includes the project directory

python -m pkg.test
[
  "/project",
  ...
]

Now, all imports can be absolute, from the project directory. No further skullduggery required.

Dusky

Answer 28

I made this library to do this.

https://github.com/fx-kirin/add_parent_path

# Just add parent path
add_parent_path(1)

# Append to syspath and delete when the exist of with statement.
with add_parent_path(1):
   # Import modules in the parent path
   pass

Mistrot

It still ought to be explained. What is the gist of it? – Squeegee

Answer 29

This is the simplest solution that works for me:

from ptdraft import nib

Geosynclinal

Answer 30

The only solution that worked for me in the IDE (PyCharm) AND in Docker with the same imports is configuring the root folder in the .ini file, as per pytest official docs

[tool.pytest.ini_options]
testpaths = ["tests"]
pythonpath = ["."]

Context: project with 2 levels deep testing folders, trying to import main code from root project path (meaning, no src folder or similar). Need to make it work with CLI, OS independent, IDE independent and it needs to be able to import in docker with the same import sentences.

Binny

Answer 31

Although it is against all rules, I still want to mention this possibility:

You can first copy the file from the parent directory to the child directory. Next import it and subsequently remove the copied file:

for example in life.py:

import os
import shutil

shutil.copy('../nib.py', '.')
import nib
os.remove('nib.py')

# now you can use it just fine:
nib.foo()

Of course there might arise several problems when nibs tries to import/read other files with relative imports/paths.

Orlov

This is a creative solution! I probably wouldn't use it though. – Haler

I would strongly advise not to use this solution, but rather to make the parent directory a package as well or just append the parent directory to your sys.path (as suggested in the other answers). Copying/removing the file introduces a very tight dependency on the file location, which may be unnoticed when changing the project in the future (and thus makes the script less robust). Also it prevents the file from being cached and of course also creates slight overhead for the needed IO. – Hardie

I understand people do downvote this post, since it is indeed bad practice, and I would never use it when writing a package or a reusable script, however it might still be worthwhile in some cases. For example, when you are running an interactive session and you just want to use some functions defined in a script in another location. I believe it is good practice that these kind of solutions are still mentioned on stackoverflow. – Orlov

I understand your remark, @Orlov and agree that it may be worth to include this on StackOverflow for reference. So why not update your answer to reflect your reasoning there, and mention some of the considerations/pitfalls which come with it? – Hardie

Answer 32

This works for me to import things from a higher folder.

import os
os.chdir('..')

Veldaveleda